'''
Created on 13/10/2013

@author: daniel
'''
import colecciones.cola
import colecciones.listaEnlazada
import colecciones.DefinicionDeGrafo.grafo
import colecciones.DefinicionDeGrafo.vertice
import unittest


class Recorridos(object):
    '''
    La clase recorridos tiene los metodos  dfs y bfs para asociarlos en un grafo, por lo
    tanto el grafo se asocia al recorrido
    '''
    def dfs(self, grafo, origen): 
        '''
        Imprime los vertices del grafo a partir del recorrido en profundidad desde 
        el vertice origen.
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__dfs__(origen, visitado)

    def __dfs__(self, origen, visitado):
        '''
        recorrido en profundidad proporcionado por la catedra
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        print origen.getDato()
        visitado[origen.getPosicion()]=True
        recorredor = origen.getListaDeAdyacentes().recorredor()
        recorredor.comenzar()
        while not recorredor.fin():
            ady = recorredor.elemento().getVerticeDestino()
            if not visitado[ady.getPosicion()]:self.__dfs__(ady, visitado)
            recorredor.proximo()
    
    def bfs(self, grafo, origen):
        '''
        Imprime los vertices del grafo a partir del recorrido en amplitud desde el vertice origen
        grafo es el entorno que contiene vertices
        origen es el vertice de partida
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__bfs__(origen, visitado)
    
    def __bfs__(self, origen, visitado):
        '''
        recorrido en amplitud proporcionado por la catedra:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        cola=colecciones.cola.Cola()
        cola.poner(origen)
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice.getPosicion()]:
                print vertice.getDato()
                visitado[vertice.getPosicion()]=True#visita al actual
                recorredor = vertice.getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:cola.poner(ady)
                    recorredor.proximo()

    def __bfsListado__(self, origen, visitado):
        '''
        recorrido en amplitud devuelto en una lista:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        cola=colecciones.cola.Cola()
        cola.poner(origen)
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice.getPosicion()]:
                lista.agregar(vertice,lista.getTamanio())
                visitado[vertice.getPosicion()]=True#visita al actual
                recorredor = vertice.getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:cola.poner(ady)
                    recorredor.proximo()
        return lista
    
    def caminoSimpleConDFS(self, grafo, origen, destino):
        '''
        Retorna una lista de vertices con el recorrido en profundidad del grafo
        recibido como parametro desde el vertice origen hasta el vertice destino
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__recCaminoSimpleDFS__(origen, lista, visitado,destino)
        return lista
            
    def __recCaminoSimpleDFS__(self,origen,lista,visitado,destino):
        if origen.__cmp__(destino)==0:return True #si encontro destino
        visitado[origen.getPosicion()]=True#sino recorre
        recorredor = origen.getListaDeAdyacentes().recorredor()
        recorredor.comenzar()
        while not recorredor.fin():
            ady = recorredor.elemento().getVerticeDestino()
            if not visitado[ady.getPosicion()]:
                if(self.__recCaminoSimpleDFS__(ady,lista,visitado,destino)==True):#si en el recorrido encuentra camino
                    lista.agregar(ady,lista.getTamanio())#guarda en la lista
                    return True#corta recorrido y devuelve para avisar que es parte del camino
            recorredor.proximo()
        return False
    
    def verticesADistanciaConBFS(self, grafo, origen, nroDeAristas):
        '''
        Retorna la lista de vertices que se encuentran a la distancia (en numeros 
        de aristas) que se indica en el parametro nroDeAristas con el recorrido en 
        amplitud del grafo recibido como parametro partiendo del vertice origen
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        if (nroDeAristas<=0):return colecciones.listaEnlazada.ListaEnlazada()
        lista=self.__bfsListadoADistancia__(origen, visitado)
#         print "Lista producida"
#         print lista
        rec=lista.recorredor()
        rec.comenzar()
        lista1=colecciones.listaEnlazada.ListaEnlazada()
        while not rec.fin():
            elem=rec.elemento()
            if (elem[1]==nroDeAristas)&(not lista1.incluye(elem[0])): 
                lista1.agregar(elem[0],0)
            rec.proximo()
        return lista1
    
    def __bfsListadoADistancia__(self,origen, visitado):
        '''
        recorrido en amplitud devuelto en una lista:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        cola=colecciones.cola.Cola()
        cola.poner([origen,0])#el cero es la distancia
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice[0].getPosicion()]:
                visitado[vertice[0].getPosicion()]=True#visita al actual
                recorredor = vertice[0].getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:
                        cola.poner([ady,vertice[1]+1])
                        lista.agregar([ady,vertice[1]+1],0)
                    recorredor.proximo()
        return lista       
    
class Test(unittest.TestCase):

    def testName(self):
        self.assertIsInstance(Recorridos(), Recorridos,"Verifica la correcta creacion de los recoridos")
    
    def testDfs(self):
        grafo=colecciones.DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        print "Recorrido En profundidad:"
        dfs=Recorridos()
        dfs.dfs(grafo, grafo.vertice(0))
         

    def testBfs(self):
        grafo=colecciones.DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        print "Recorrido en amplitud:"
        bfs=Recorridos()
        bfs.bfs(grafo, grafo.vertice(0))
        
    def testCaminoSimpleConDFS(self):
        grafo=colecciones.DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        camino=Recorridos()
        lista=camino.caminoSimpleConDFS(grafo,grafo.vertice(0),grafo.vertice(4))
        '''
        se verifica camino mas profundo desde el vertice que contiene el 1
        hasta el vertice que contiene al 5
        '''
        self.assertEquals(lista.elemento(3),grafo.vertice(3), "verifica comino siguiente al vertice 0,es el que contiene al 4")
        self.assertEquals(lista.elemento(2),grafo.vertice(5), "verifica comino siguiente al vertice 3,es el que contiene al 6")
        self.assertEquals(lista.elemento(1),grafo.vertice(2), "verifica comino siguiente al vertice 5,es el que contiene al 3")
        self.assertEquals(lista.elemento(0),grafo.vertice(4), "verifica comino siguiente al vertice 2,es el que contiene al 5")
        

    def testVerticesADistanciaConBFS(self):
        grafo=colecciones.DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 colecciones.DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        camino=Recorridos()
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),0).esVacia(),"Verifica que no hay vertices a distancia 0")
        self.assertIsNotNone(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1),"Verifica que hay vertices a distancia 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1).elemento(0),grafo.vertice(3),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 4 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 2 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(0),grafo.vertice(5),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 6 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 2 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(2),grafo.vertice(2),"verifica que el tercer elemento de la lista de vertices desde el 1 sea el vertice 3 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(3),grafo.vertice(4),"verifica que el cuarto elemento de la lista de vertices desde el 1 sea el vertice 5 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(0),grafo.vertice(2),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 3 con dist 3")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(1),grafo.vertice(4),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 5 con dist 3")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(2),grafo.vertice(6),"verifica que el tercer elemento de la lista de vertices desde el 1 sea el vertice 7 con dist 3")
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),4).esVacia(),"verifica que  la lista de vertices desde el 1 sea vacia a dist 4")
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),0).esVacia(),"Verifica que no hay vertices a distancia 0")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),1).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 2 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),2).elemento(0),grafo.vertice(6),"verifica que el segundo elemento de la lista de vertices desde el 2 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),1).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 3 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),2).elemento(0),grafo.vertice(6),"verifica que el segundo elemento de la lista de vertices desde el 3 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(0),grafo.vertice(5),"verifica que el primer elemento de la lista de vertices desde el 4 sea el vertice 6 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 4 sea el vertice 2 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(2),grafo.vertice(2),"verifica que el tercer elemento de la lista de vertices desde el 4 sea el vertice 3 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(3),grafo.vertice(4),"verifica que el cuarto elemento de la lista de vertices desde el 4 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(0),grafo.vertice(2),"verifica que el primer elemento de la lista de vertices desde el 4 sea el vertice 3 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(1),grafo.vertice(4),"verifica que el segundo elemento de la lista de vertices desde el 4 sea el vertice 5 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(2),grafo.vertice(6),"verifica que el tercer elemento de la lista de vertices desde el 4 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),1).elemento(0),grafo.vertice(6),"verifica que el primer elemento de la lista de vertices desde el 5 sea el vertice 7 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1).elemento(0),grafo.vertice(6),"verifica que el primer elemento de la lista de vertices desde el 6 sea el vertice 7 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1).elemento(1),grafo.vertice(2),"verifica que el segundo elemento de la lista de vertices desde el 6 sea el vertice 3 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),2).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 6 sea el vertice 5 con dist 5")
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),7)
        
if __name__ == "__main__":
    #import sys;sys.argv = ['', 'Test.testName']
    unittest.main()